package cn.cosmosx.base.util;

import cn.cosmosx.base.function.ExceptionFunc;
import cn.cosmosx.base.function.ICallBackFunc;
import cn.cosmosx.base.function.ICallFunc;

import java.util.Optional;

/**
 * 基于函数式的快速处理工具
 *
 * @author gengzhy
 */
public final class FastHandlerUtils {

    /**
     * 参数不为空执行回调，无返回值
     *
     * @param value - 参数
     * @param call  - 回调函数
     */
    public static void notNullCall(Object value, ICallFunc call) {
        isTrueCall(ObjectsUtil.isNotNull(value), call);
    }

    /**
     * 参数为true时执行回调，无返回值
     *
     * @param bool - 参数
     * @param call - 回调函数
     */
    public static void isTrueCall(boolean bool, ICallFunc call) {
        if (bool) {
            call.execute();
        }
    }

    /**
     * 参数不为空执行回调，否则执行异常回调函数，抛出异常信息，无返回值
     *
     * @param value  - 参数
     * @param call   - 回调函数
     * @param exCall - 异常回调函数
     */
    public static <EX extends RuntimeException> void notNullCallElseThrow(Object value, ICallFunc call, ExceptionFunc<EX> exCall) {
        isTrueCallElseThrow(ObjectsUtil.isNotNull(value), call, exCall);
    }

    /**
     * 参数为true时执行回调，否则执行异常回调函数，抛出异常信息，无返回值
     *
     * @param bool   - 参数
     * @param call   - 回调函数
     * @param exCall - 异常回调函数
     */
    public static <EX extends RuntimeException> void isTrueCallElseThrow(boolean bool, ICallFunc call, ExceptionFunc<EX> exCall) {
        if (bool) {
            call.execute();
        }
        throw Optional.ofNullable(exCall.get()).orElseThrow(() -> new RuntimeException("exCall不能为空"));
    }

    /**
     * 参数不为空执行回调，抛出异常信息，有返回值
     *
     * @param value - 参数
     * @param call  - 回调函数
     * @param <R>   - 返回值类型
     * @return - 返回值
     */
    public static <R> R notNullCallBack(Object value, ICallBackFunc<R> call) {
        return isTrueCallBack(ObjectsUtil.isNotNull(value), call);
    }

    /**
     * 参数true时执行回调，抛出异常信息，有返回值
     *
     * @param bool - 参数
     * @param call - 回调函数
     * @param <R>  - 返回值类型
     * @return - 返回值
     */
    public static <R> R isTrueCallBack(boolean bool, ICallBackFunc<R> call) {
        return bool ? call.execute() : null;
    }

    /**
     * 参数不为空执行回调，否则执行异常回调函数，抛出异常信息，有返回值
     *
     * @param value  - 参数
     * @param call   - 回调函数
     * @param exCall - 异常回调函数
     * @param <R>    - 返回值类型
     * @return - 返回值
     */
    public static <R, EX extends RuntimeException> R notNullCallBackElseThrow(Object value, ICallBackFunc<R> call, ExceptionFunc<EX> exCall) {
        return isTrueCallBackElseThrow(ObjectsUtil.isNotNull(value), call, exCall);
    }

    /**
     * 参数true时执行回调，否则执行异常回调函数，抛出异常信息，有返回值
     *
     * @param bool   - 参数
     * @param call   - 回调函数
     * @param exCall - 异常回调函数
     * @param <R>    - 返回值类型
     * @return - 返回值
     */
    public static <R, EX extends RuntimeException> R isTrueCallBackElseThrow(boolean bool, ICallBackFunc<R> call, ExceptionFunc<EX> exCall) {
        if (bool) {
            return call.execute();
        }
        throw Optional.ofNullable(exCall.get()).orElseThrow(() -> new RuntimeException("exCall不能为空"));
    }
}

